// 引入请求的函数 , 名字
import {
  login,
  signUp,
  seekUser,
  addRequest,
  selectRequest,
  consent,
  refuse,
  reName,
  rePass,
  getFriends,
  deleteFriend
} from '@/api/user'
// 引入操作的Cook的函数
import {getToken, getAvatar, getName, getId, setToken, removeToken, setName, setAvatar, setId} from '@/utils/auth'
// 引入Router
import {resetRouter} from '@/router'


// 关于 用户登录注册时的全局的方法函数
const getDefaultState = () => {
  return {
    token: getToken(),      //用户的Token
    id: getId(),            //用户的账号
    name: getName(),        //用户的昵称
    avatar: getAvatar(),    //用户的头像
    webSocket: {},          //客户端的WebSocket对象
    connection: true,       //判断 , 是否可用进行连接
    friends: [],
  }
}
const state = getDefaultState()

const mutations = {
  //重置state里面的全部的数据
  RESET_STATE: (state) => {
    // state.webSocket.close()
    Object.assign(state, getDefaultState())
    console.log("重置state里面的全部的数据");
  },
  //保存用户的Token
  SET_TOKEN: (state, token) => {
    state.token = token
    console.log("保存Token的信息:" + token);
  },
  //设置用户的账号
  SET_ID: (state, id) => {
    state.id = id;
    console.log("保存用户的账号 : " + id);
  },
  //设置用户的昵称
  SET_NAME: (state, name) => {
    state.name = name
    console.log("保存用户的昵称 : " + name);
  },
  // 设置用户的头像
  SET_AVATAR: (state, avatar) => {
    state.avatar = avatar
    console.log("保存用户的头像 : " + avatar);
  },
  // 设置用户的WebSocket对象
  SET_WEBSOCKET: (state, socket) => {
    state.webSocket = socket;
    console.log("保存用户WeSocket对象 : " + socket);
  },
  SET_CONNECTION: (state) => {
    state.connection = false;
  },

//  向朋友列表里面,  添加一条数据
  ADD_FRIEND: (state, friend) => {
    state.friends.push({
      value: friend.name,
      id: friend.id,
      url: friend.url,
      name: friend.name,
    })
  },

  DELETE_FRIEND(state, findid) {
    for (var i = 0; i < state.friends.length; i++) {
      //判断 , 如果账号 , 相同 , 则删除这个消息
      if (state.friends[i].id == findid) {
        //移除一个元素
        state.friends.splice(i, 1);
        return;
      }
    }
  }
}
const actions = {
  //同意用户请的函数
  consent({commit}, userinfo) {
    //  向服务端 , 发送一个请求 , 用于同意请求 , 互加好友
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      consent({id: userinfo}).then(() => {
        resolve()
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //拒绝用户的请求的函数 refuse
  refuse({commit}, userinfo) {
    //  向服务端 , 发送一个请求 , 用于同意请求 , 互加好友
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      refuse({id: userinfo}).then(() => {
        resolve()
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  selectRequest() {
    // 发送请求 , 得到返回的参数
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      selectRequest().then(response => {
        console.log("请求发送成功 , 返回过来了");
        resolve(response)
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //发送请求消息 , 把请求发送到服务端 进行保存,  并进行保存请求消息
  addRequest({commit}, userinfo) {
    console.log("发送请求消息 , 进来了");
    // 发送请求 , 得到返回的参数 , 把参数返回出去
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      addRequest(userinfo).then(response => {
        console.log("请求发送成功 , 返回过来了");
        resolve()
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //搜索用户的账号 , 并把用户的账号 , 返回到客户端 , 进行展示
  seekUser({commit}, userinfo) {
    console.log("搜索 , 进来了");
    // 发送请求 , 得到返回的参数 , 把参数返回出去
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      seekUser({id: userinfo}).then(response => {
        console.log("登录的请求 , 返回过来了");
        // 获取Tocken对象
        const {data} = response;
        console.log("搜索得到反馈的数据:" + data);
        // 返回一个成功的回调函数
        resolve(data)
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  // 登录 函数 , 到服务端请求token
  login({commit}, userInfo) {
    console.log("登录 , 进来了");
    // 获取参数对象
    const {userId, userPass} = userInfo
    // 发送请求 , 得到返回的参数 , 把参数返回出去
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      login({id: userId, password: userPass}).then(response => {
        console.log("登录的请求 , 返回过来了");
        // 获取Tocken对象
        const {data} = response;
        //获取到服务端返回过来的token, , 并把Token保存起来 ,
        commit('SET_TOKEN', data.token)
        //保存用户的账号
        commit('SET_ID', data.user.id)
        //保存用户的昵称
        commit('SET_NAME', data.user.name)
        //保存用户的头像
        commit('SET_AVATAR', data.user.avater)
        //把用户的信息 , 保存到cookie里面
        setToken(data.token)
        setId(data.user.id)
        setName(data.user.name)
        setAvatar(data.user.avater)
        // 返回一个成功的回调函数
        resolve()
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //注册 函数 , 到服务端 保存数据 , , 请求Tocken
  sign({commit}, userInfo) {
    console.log("注册2");
    //  获取数据的参数
    const {userid, username, userpass} = userInfo
    // 发送请求 , 得到返回的参数 , 把参数返回出去
    return new Promise((resolve, reject) => {
      //把数据 , 通过 , 请求 , 发送到服务器 , 进行保存
      signUp({id: userid, name: username, password: userpass}).then(responce => {
        console.log("服务端的注册请求 , 过来了");
        const {data} = responce;
        //获取到服务端返回过来的token, , 并把Token保存起来 ,
        commit('SET_TOKEN', data.token)
        //保存用户的账号
        commit('SET_ID', data.user.id)
        //保存用户的昵称
        commit('SET_NAME', data.user.name)
        //保存用户的头像
        commit('SET_AVATAR', data.user.avater)
        //把用户的信息 , 保存到cookie里面
        setToken(data.token)
        setId(data.user.id)
        setName(data.user.name)
        setAvatar(data.user.avater)
        resolve()
      }).catch(error => {
        console.log("失败的响应信息");
        //  执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //退出按钮 . 删除Token1的方法
  logout({commit, state}) {
    return new Promise((resolve) => {
      removeToken() // 删除Token信息
      resetRouter() // 删除当前Vuex里面的全部的数据
      commit('RESET_STATE')
      resolve()
    })
  },

  //修改用户的昵称 reName
  reName({commit}, userinfo) {
    console.log("搜索 , 进来了");
    // 发送请求 , 得到返回的参数 , 把参数返回出去
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      reName({name: userinfo}).then(() => {
        // 返回一个成功的回调函数
        //保存用户的昵称
        commit('SET_NAME', userinfo)
        setName(userinfo)
        resolve()
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //修改用户的密码 rePass
  rePass({commit}, userinfo) {
    console.log("搜索 , 进来了");
    // 发送请求 , 得到返回的参数 , 把参数返回出去
    return new Promise((resolve, reject) => {
      // 把数据 , 通过请求 , 发送到服务端 ,进行请求 , 得到对应的Token
      rePass({password: userinfo}).then(() => {
        removeToken() // 删除Token信息
        resetRouter() // 删除当前Vuex里面的全部的数据
        commit('RESET_STATE')
        resolve()
      }).catch(error => {
        // 执行一个失败的回调函数
        reject(error)
      })
    })
  },

  //修改用户的头像 reimages
  reimages({commit}, userinfo) {
    const {avatar} = userinfo
    //保存用户的头像
    commit('SET_AVATAR', avatar)
  },

  // 获取用户的朋友的信息 , 以及 , 聊天信息
  getFriends({commit}) {
    return new Promise((resolve, reject) => {
      if (state.connection) {
        getFriends().then(response => {
          const {data} = response
          //得到服务端 , 返回的数据 , 把数据 ,进行遍历取出 , 展示出来
          for (var i = 0; i < data.friends.length; i++) {
            //  把用户 . 添加到Vuex里面
            commit('ADD_FRIEND', data.friends[i]);
          }
          commit('SET_CONNECTION');
          resolve()
        }).catch(error => {
          reject(error)
        })
      } else {
        resolve();
      }
    })
  },

  // 删除指定用户的朋友
  deleteFriend({commit}, Userinfo) {
    return new Promise((resolve, reject) => {
      deleteFriend({id: Userinfo}).then(() => {
        //删除成功 , 则把Vuex里面的数据 , 也删除了 DELETE_FRIEND
        commit('DELETE_FRIEND', Userinfo);
        resolve()
      }).catch(error => {
        reject(error)
      })
    })
  },

  // 初始化WebSocket对象 , 并接受来自 , 服务端的消息
  initWebSocket({commit}) {
    //判断 , WebSocket是否已经连接过了
    var wsProtocol = '';
    return new Promise((resolve, reject) => {
      if (state.connection) {
        //设置用户信息
        if (window.location.protocol == "http:") {
          // wsProtocol = "ws://www.hrkj.fit:8090/lep2/WeChat/websocket/" + this.user.userid;
          wsProtocol = "ws://192.168.2.122:8080/websocket/" + state.id;
        } else {
          // wsProtocol = "wss://www.hrkj.fit:8090/lep2/WeChat/websocket/" + this.user.userid;
          wsProtocol = "wss://192.168.2.122:8080/websocket/" + state.id;
        }
        //判断浏览器是否支持WebSocket
        if ("WebSocket" in window) {
          //修改Vuex 里面的WebSocket里面的webSocket对象
          commit('SET_WEBSOCKET', new WebSocket(wsProtocol));
          resolve()
        } else {
        reject()
        }
      }
    });
  },
//  向朋友列表里面 , 保存一条数据
  addFriends({commit}, friend) {
    commit('ADD_FRIEND', friend);
  },
//  向朋友列表里面 , 删除一条数据
  deleteFriends({commit}, friend) {
    commit('DELETE_FRIEND', friend);
  },

}

export default {
  namespaced: true,
  state,
  mutations,
  actions
}

